home *** CD-ROM | disk | FTP | other *** search
/ MacTech 1 to 12 / MacTech-vol-1-12.toast / Source / MacTech® Magazine / Volume 04 - 1988 / 04.12 Dec 88 / Twindow / TWindowTester.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-04-29  |  17.2 KB  |  942 lines  |  [TEXT/MPS ]
  1. /*
  2.  *    TWindowTester
  3.  *
  4.  *    C source of a simple program to demonstrate usage of tool windows by
  5.  *    using routines from the TWindow Manager.  Tool windows  are  windows
  6.  *    that always float on top, typically for palettes and tools.
  7.  *
  8.  *        Thomas Fruin 1988
  9.  *
  10.  *        fruin@hlerul5.BITNET            University of Leiden
  11.  *        thomas@uvabick.UUCP                University of Amsterdam
  12.  *        dibs@well.UUCP
  13.  *        hol0066.AppleLink
  14.  *        2:508/15.FidoNet                The Netherlands
  15.  *
  16.  *    TWindowTester is based on MiniEdit - Mini text editor,converted from
  17.  *    the listing in Macintosh Revealed, vol II. As little as possible was
  18.  *    modified in the original program, although most of the functionality
  19.  *    is no longer there.
  20.  */
  21.  
  22.  
  23. #include <Types.h>
  24. #include <QuickDraw.h>
  25. #include <Fonts.h>
  26. #include <Windows.h>
  27. #include <Events.h>
  28. #include <TextEdit.h>
  29. #include <Controls.h>
  30. #include <Dialogs.h>
  31. #include <Menus.h>
  32. #include <Memory.h>
  33. #include <OSUtils.h>
  34. #include <ToolUtils.h>
  35. #include <Desk.h>
  36.  
  37. #include <TWindows.h>
  38.  
  39. #define MenuBarHeight    20
  40. #define TitleBarHeight    18
  41. #define ScreenMargin     4
  42.  
  43. #define MinWidth        80
  44. #define MinHeight        80
  45. #define SBarWidth        16
  46.  
  47. #define AppleID             1
  48. #define AboutItem         1
  49.  
  50. #define FileID             2
  51. #define NewItem             1
  52. #define    NewToolItem         2
  53. #define CloseItem         3
  54. #define QuitItem         5
  55.  
  56. #define EditID             3
  57. #define UndoItem         1
  58. #define CutItem             3
  59. #define CopyItem         4
  60. #define PasteItem         5
  61. #define ClearItem         7
  62.  
  63. #define    WindowsID         4
  64.  
  65. #define    ToolsID             5
  66.  
  67. #define AboutID           128
  68. #define windowID      1000
  69. #define scrollID      1000
  70. #define    toolID          1001
  71.  
  72. #define    okButton         1
  73. #define    aboutBold         8
  74.  
  75. #define wHOffset        20
  76. #define wVOffset        20
  77. #define tHOffset        40
  78. #define tVOffset        40
  79.  
  80. #define undoCmd             0
  81. #define cutCmd             2
  82. #define copyCmd             3
  83. #define pasteCmd         4
  84. #define clearCmd         5
  85.  
  86.     /* z-ordered list of windows (nearest first) */
  87.     
  88. #define windowList        (*(WindowPeek *)0x9D6)
  89. #define    nilproc            ((ProcPtr)0)
  90.  
  91. struct WindowData
  92. {
  93.     ControlHandle scBar;
  94. };
  95.  
  96. typedef struct WindowData    WindowData;
  97. typedef struct WindowData    *WDPtr;
  98. typedef struct WindowData    **WDHandle;
  99.  
  100. MenuHandle        AppleMenu,
  101.                 FileMenu,
  102.                 EditMenu,
  103.                 WindowsMenu,
  104.                 ToolsMenu;
  105.                 
  106. INTEGER            toolCount,
  107.                 windowCount,
  108.                 lastToolsItem,
  109.                 lastWindowsItem;
  110.                 
  111. Boolean            Finished,
  112.                 ErrorFlag;
  113.  
  114. main()
  115. {
  116.     Initialize();
  117.  
  118.     do
  119.     {
  120.         if ( FrontWindow() == nil )
  121.             DisableItem( FileMenu, CloseItem );
  122.         SystemTask();
  123.         DoEvent();
  124.     }
  125.     while ( !Finished );
  126. }
  127.  
  128. Initialize()
  129. {
  130.     INTEGER        theMask;
  131.  
  132.     InitGraf( &qd.thePort );
  133.     InitFonts();
  134.     InitWindows();
  135.     InitMenus();
  136.     TEInit();
  137.     InitDialogs( nilproc );
  138.     
  139.     TInitWindows();
  140.  
  141.     theMask = everyEvent - keyUpMask;
  142.     SetEventMask( theMask );
  143.     FlushEvents( everyEvent, 0 );
  144.  
  145.     SetUpMenus();
  146.     InitCursor();
  147. }
  148.  
  149. SetUpMenus()
  150. {
  151.     AppleMenu = GetMenu( AppleID );
  152.     AddResMenu( AppleMenu, 'DRVR' );
  153.     InsertMenu( AppleMenu, 0 );
  154.  
  155.     FileMenu = GetMenu( FileID );
  156.     InsertMenu( FileMenu, 0 );
  157.  
  158.     EditMenu = GetMenu( EditID );
  159.     InsertMenu( EditMenu, 0 );
  160.     
  161.     WindowsMenu = GetMenu( WindowsID );
  162.     InsertMenu( WindowsMenu, 0 );
  163.     
  164.     ToolsMenu = GetMenu( ToolsID );
  165.     InsertMenu( ToolsMenu, 0 );
  166.  
  167.     DrawMenuBar();
  168.     
  169.     lastToolsItem   =
  170.     lastWindowsItem = 0;
  171. }
  172.  
  173. DoEvent()
  174. {
  175.     EventRecord    theEvent;
  176.     
  177.     ErrorFlag = false;
  178.  
  179.     if ( TGetNextEvent( everyEvent, &theEvent ))
  180.     {
  181.         switch ( theEvent.what )
  182.         {
  183.             case mouseDown:
  184.                 DoMouseDown( &theEvent );
  185.                 break;
  186.                 
  187.             case keyDown:
  188.             case autoKey:
  189.                 DoKeyStroke( &theEvent );
  190.                 break;
  191.                 
  192.             case updateEvt:
  193.                 DoUpdate( &theEvent );
  194.                 break;
  195.                 
  196.             case activateEvt:
  197.                 DoActivate( &theEvent );
  198.                 break;
  199.                 
  200.             default:
  201.                 break;
  202.         }
  203.     }
  204. }
  205.  
  206. DoMouseDown( theEvent )
  207.     EventRecord    *theEvent;
  208. {
  209.     WindowPtr    whichWindow;
  210.     INTEGER        thePart;
  211.  
  212.     thePart = FindWindow( &theEvent->where, &whichWindow );
  213.  
  214.     switch ( thePart )
  215.     {
  216.         case inDesk:
  217.             break;
  218.             
  219.         case inMenuBar:
  220.             DoMenuClick( theEvent );
  221.             break;
  222.             
  223.         case inSysWindow:
  224.             SystemClick( theEvent, whichWindow );
  225.             break;
  226.             
  227.         case inContent:
  228.             DoContent( theEvent, whichWindow );
  229.             break;
  230.             
  231.         case inDrag:
  232.             DoDrag( theEvent, whichWindow );
  233.             break;
  234.             
  235.         case inGrow:
  236.             DoGrow( theEvent, whichWindow );
  237.             break;
  238.             
  239.         case inGoAway:
  240.             DoGoAway( theEvent, whichWindow );
  241.             break;
  242.     }
  243. }
  244.  
  245. DoMenuClick( theEvent )
  246.     EventRecord    *theEvent;
  247. {
  248.     LONGINT    menuChoice;
  249.  
  250.     menuChoice = MenuSelect( &theEvent->where );
  251.     DoMenuChoice( menuChoice );
  252. }
  253.  
  254. DoMenuChoice( menuChoice )
  255.     LONGINT        menuChoice;
  256. {
  257.     INTEGER        theMenu,
  258.                 theItem;
  259.  
  260.     if ( menuChoice )
  261.     {
  262.         theMenu = HiWord( menuChoice );
  263.         theItem = LoWord( menuChoice );
  264.  
  265.         switch (theMenu)
  266.         {
  267.             case AppleID:
  268.                 DoAppleChoice( theItem );
  269.                 break;
  270.                 
  271.             case FileID:
  272.                 DoFileChoice( theItem );
  273.                 break;
  274.                 
  275.             case EditID:
  276.                 DoEditChoice( theItem );
  277.                 break;
  278.             
  279.             case WindowsID:
  280.                 DoWindowsChoice( WindowsMenu, theItem );
  281.                 break;
  282.             
  283.             case ToolsID:
  284.                 DoWindowsChoice( ToolsMenu, theItem );
  285.                 break;
  286.         }
  287.         HiliteMenu( 0 );
  288.     }
  289. }
  290.  
  291. DoAppleChoice( theItem )
  292.     INTEGER        theItem;
  293. {
  294.     char        accName[255];
  295.     INTEGER        accNumber;
  296.  
  297.     switch ( theItem )
  298.     {
  299.         case AboutItem:
  300.             DoAbout();
  301.             break;
  302.             
  303.         default:
  304.             EnableItem( FileMenu, CloseItem );
  305.  
  306.             EnableItem( EditMenu, UndoItem  );
  307.             EnableItem( EditMenu, CutItem   );
  308.             EnableItem( EditMenu, CopyItem  );
  309.             EnableItem( EditMenu, PasteItem );
  310.             EnableItem( EditMenu, ClearItem );
  311.             
  312.             GetItem( AppleMenu, theItem, accName );
  313.             accNumber = OpenDeskAcc( accName );
  314.             break;
  315.     }
  316. }
  317.  
  318. DoAbout()
  319. {
  320.     EventRecord    theEvent;
  321.     DialogPtr    aboutDialog;
  322.     INTEGER        theItem;
  323.     void            SetBold();
  324.     
  325.     aboutDialog = GetNewDialog( AboutID, nil, inFront );
  326.     SetBold( aboutDialog, aboutBold );
  327.     TShowWindow( aboutDialog );
  328.  
  329.     if ( TGetNextEvent( activMask, &theEvent ))
  330.         DoActivate( &theEvent );
  331.     
  332.     if ( TGetNextEvent( activMask, &theEvent ))
  333.         DoActivate( &theEvent );
  334.     
  335.     ModalDialog( nilproc, &theItem );
  336.     
  337.     THideWindow ( aboutDialog );
  338.     DisposDialog( aboutDialog );
  339. }
  340.  
  341. DoFileChoice( theItem )
  342.     INTEGER        theItem;
  343. {
  344.     switch (theItem)
  345.     {
  346.         case NewItem:
  347.             DoNew();
  348.             break;
  349.             
  350.         case NewToolItem:
  351.             DoNewTool();
  352.             break;
  353.             
  354.         case CloseItem:
  355.             DoClose();
  356.             break;
  357.             
  358.         case QuitItem:
  359.             DoQuit();
  360.             break;
  361.     }
  362. }
  363.  
  364. DoNew()
  365. {
  366.     WindowPtr    theWindow;
  367.     WDHandle    theData;
  368.     char        title[ 255 ];
  369.  
  370.     theWindow = TGetNewWindow( userKind, windowID, nil, inFront );
  371.  
  372.     OffsetWindow( theWindow, wHOffset, wVOffset, &windowCount );
  373.     TShowWindow ( theWindow );
  374.  
  375.     SetPort( theWindow );
  376.  
  377.     theData = ( WDHandle )NewHandle(( Size )sizeof( WindowData ));
  378.     SetWRefCon( theWindow, ( LONGINT )theData );
  379.     HLock( theData );
  380.  
  381.     ( *theData )->scBar = GetNewControl( scrollID, theWindow );
  382.  
  383.     HUnlock( theData );
  384.  
  385.     EnableItem( FileMenu, CloseItem );
  386.     
  387.     GetWTitle( theWindow, title );
  388.     InsMenuItem( WindowsMenu, title, lastWindowsItem++ );
  389.     CheckItem  ( WindowsMenu, lastWindowsItem, true );
  390. }
  391.  
  392. DoNewTool()
  393. {
  394.     WindowPtr    toolWindow;
  395.     char        title[ 255 ];
  396.  
  397.     toolWindow = TGetNewWindow( toolKind, toolID, nil, inFront );
  398.     
  399.     OffsetWindow( toolWindow, tHOffset, tVOffset, &toolCount );
  400.     TShowWindow( toolWindow );
  401.     
  402.     SetPort( toolWindow );
  403.     
  404.     EnableItem( FileMenu, CloseItem );
  405.     
  406.     GetWTitle( toolWindow, title );
  407.     InsMenuItem( ToolsMenu, title, lastToolsItem++ );
  408.     CheckItem  ( ToolsMenu, lastToolsItem, true );
  409. }
  410.  
  411. OffsetWindow( whichWindow, hOffset, vOffset, count )
  412.     WindowPtr    whichWindow;
  413.     INTEGER        hOffset,
  414.                 vOffset,
  415.                 *count;
  416. {
  417.     INTEGER        windowWidth,
  418.                 windowHeight,
  419.                 hExtra,
  420.                 vExtra,
  421.                 hMax,
  422.                 vMax,
  423.                 windowLeft,
  424.                 windowTop;
  425.     Rect        pRect;
  426.     char        title [ 255 ],
  427.                 number[ 3 ];
  428.  
  429.     pRect = whichWindow->portRect;
  430.  
  431.     windowWidth   = pRect.right - pRect.left;
  432.     windowHeight  = pRect.bottom - pRect.top;
  433.     windowHeight += TitleBarHeight;
  434.  
  435.     hExtra = qd.screenBits.bounds.right  -   windowWidth;
  436.     vExtra = qd.screenBits.bounds.bottom - ( windowHeight + MenuBarHeight );
  437.  
  438.     hMax = ( hExtra / hOffset ) + 1;
  439.     vMax = ( vExtra / vOffset ) + 1;
  440.  
  441.     ++*count;
  442.  
  443.     windowLeft = ( *count % hMax ) * hOffset;
  444.     windowTop  = ( *count % vMax ) * vOffset;
  445.     windowTop  = windowTop + TitleBarHeight + MenuBarHeight;
  446.  
  447.     MoveWindow( whichWindow, windowLeft, windowTop, false );
  448.     
  449.     GetWTitle( whichWindow, title );
  450.     NumToString(( LONGINT )*count, number );
  451.     SetWTitle( whichWindow, strcat( title, number ));
  452. }
  453.  
  454. DoClose()
  455. {
  456.     WindowPtr    whichWindow;
  457.     INTEGER        theWKind;
  458.     
  459.     whichWindow = TFrontWindow( userKind );
  460.     
  461.     if ( whichWindow != nil )
  462.     {
  463.         theWKind = TGetWKind( whichWindow );
  464.         switch( theWKind )
  465.         {
  466.             case userKind:
  467.                     CloseDocWindow( whichWindow );
  468.                     break;
  469.                     
  470.             case systemKind:
  471.                     CloseSysWindow ( whichWindow );
  472.                     break;
  473.         }
  474.     }
  475.     else
  476.     {
  477.         whichWindow = TFrontWindow( toolKind );
  478.         
  479.         if ( whichWindow != nil )
  480.             CloseToolWindow( whichWindow );
  481.     }
  482. }
  483.  
  484. CloseDocWindow( whichWindow )
  485.     WindowPtr    whichWindow;
  486. {
  487.     WDHandle    theData;
  488.     INTEGER        ItemOf();
  489.     EventRecord    theEvent;
  490.  
  491.     lastWindowsItem--;
  492.     DelMenuItem( WindowsMenu, ItemOf( whichWindow, WindowsMenu ));
  493.     
  494.     theData = ( WDHandle )GetWRefCon( whichWindow );
  495.     
  496.     THideWindow( whichWindow );
  497.  
  498.     if ( TGetNextEvent( activMask, &theEvent ))
  499.         DoActivate( &theEvent );
  500.     
  501.     if ( TGetNextEvent( activMask, &theEvent ))
  502.         DoActivate( &theEvent );
  503.  
  504.     if ( theData != nil )
  505.         DisposHandle( theData );
  506.     TDisposeWindow( whichWindow );
  507. }
  508.  
  509. CloseToolWindow( whichWindow )
  510.     WindowPtr    whichWindow;
  511. {
  512.     INTEGER        ItemOf();
  513.     
  514.     lastToolsItem--;
  515.     DelMenuItem( ToolsMenu, ItemOf( whichWindow, ToolsMenu ));
  516.     TDisposeWindow( whichWindow );
  517. }
  518.  
  519. CloseSysWindow( whichWindow )
  520.     WindowPtr    whichWindow;
  521. {
  522.     INTEGER        accNumber;
  523.  
  524.     accNumber = (( WindowPeek )whichWindow )->windowKind;
  525.     CloseDeskAcc( accNumber );
  526. }
  527.  
  528. DoQuit()
  529. {
  530.     Finished = true;
  531. }
  532.  
  533. DoEditChoice( theItem )
  534.     INTEGER        theItem;
  535. {
  536.     switch ( theItem )
  537.     {
  538.         case UndoItem:
  539.             if ( !SystemEdit( undoCmd  ))
  540.                 DoUndo();
  541.             break;
  542.             
  543.         case CutItem:
  544.             if ( !SystemEdit( cutCmd   ))
  545.                 DoCut();
  546.             break;
  547.             
  548.         case CopyItem:
  549.             if ( !SystemEdit( copyCmd  ))
  550.                 DoCopy();
  551.             break;
  552.             
  553.         case PasteItem:
  554.             if ( !SystemEdit( pasteCmd ))
  555.                 DoPaste();
  556.             break;
  557.             
  558.         case ClearItem:
  559.             if ( !SystemEdit(clearCmd  ))
  560.                 DoClear();
  561.             break;
  562.     }
  563. }
  564.  
  565. DoUndo()
  566. {
  567.     SysBeep(1);
  568. }
  569.  
  570. DoCut()
  571. {
  572.     SysBeep(1);
  573. }
  574.  
  575. DoCopy()
  576. {
  577.     SysBeep(1);
  578. }
  579.  
  580. DoPaste()
  581. {
  582.     SysBeep(1);
  583. }
  584.  
  585. DoClear()
  586. {
  587.     SysBeep(1);
  588. }
  589.  
  590. DoWindowsChoice( theMenu, theItem )
  591.     MenuHandle    theMenu;
  592.     INTEGER        theItem;
  593. {
  594.     INTEGER        theMark;
  595.     WindowPtr    whichWindow,
  596.                 WindowOf();
  597.     
  598.     whichWindow = WindowOf( theMenu, theItem );
  599.     GetItemMark( theMenu, theItem, &theMark );
  600.         
  601.     if ( theMark == noMark )
  602.     {
  603.         CheckItem( theMenu, theItem, true );
  604.         TShowWindow( whichWindow );
  605.     }
  606.     else
  607.     {
  608.         CheckItem( theMenu, theItem, false );
  609.         THideWindow( whichWindow );
  610.     }
  611. }
  612.  
  613. DoContent( theEvent, whichWindow )
  614.     EventRecord    *theEvent;
  615.     WindowPtr    whichWindow;
  616. {
  617.     INTEGER        theWKind;
  618.  
  619.     theWKind = TGetWKind( whichWindow );
  620.  
  621.     if ( theWKind == userKind )
  622.     {
  623.         if ( whichWindow != TFrontWindow( userKind ))
  624.             TSelectWindow( whichWindow );
  625.     }
  626.     else if ( theWKind == toolKind )
  627.     {
  628.         if ( whichWindow != TFrontWindow( toolKind ))
  629.             TSelectWindow( whichWindow );
  630.         
  631.         /* Only if the window has no title bar */
  632.         
  633.         DoDrag( theEvent, whichWindow );
  634.     }
  635. }
  636.  
  637. DoDrag( theEvent, whichWindow)
  638.     EventRecord    *theEvent;
  639.     WindowPtr    whichWindow;
  640. {
  641.     Rect         limitRect;
  642.  
  643.     SetRect( &limitRect, 0, MenuBarHeight, 
  644.                         qd.screenBits.bounds.right, 
  645.                         qd.screenBits.bounds.bottom );
  646.     InsetRect( &limitRect, ScreenMargin, ScreenMargin );
  647.     TDragWindow( whichWindow, theEvent, &limitRect );
  648. }
  649.  
  650. DoGrow( theEvent, whichWindow )
  651.     EventRecord    *theEvent;
  652.     WindowPtr    whichWindow;
  653. {
  654.     Rect        sizeRect;
  655.     LONGINT        newSize;
  656.     INTEGER        newWidth,
  657.                 newHeight;
  658.     GrafPtr        savePort;
  659.  
  660.     if ( whichWindow != TFrontWindow( userKind ))
  661.         TSelectWindow( whichWindow );
  662.     else
  663.     {
  664.         SetRect( &sizeRect, MinWidth, MinHeight,
  665.                             qd.screenBits.bounds.right,
  666.                             qd.screenBits.bounds.bottom - MenuBarHeight );
  667.         newSize = GrowWindow( whichWindow, &theEvent->where, &sizeRect );
  668.  
  669.         if ( newSize )
  670.         {
  671.             GetPort( &savePort );
  672.             SetPort( whichWindow );
  673.             EraseRect( &whichWindow->portRect );
  674.             newWidth  = LoWord( newSize );
  675.             newHeight = HiWord( newSize );
  676.             SizeWindow( whichWindow, newWidth, newHeight, true );
  677.             InvalRect( &whichWindow->portRect );
  678.             FixScrollBar( whichWindow );
  679.             SetPort( savePort );
  680.         }
  681.     }
  682. }
  683.  
  684. FixScrollBar( whichWindow )
  685.     WindowPtr        whichWindow;
  686. {
  687.     WDHandle        theData;
  688.     ControlHandle    theScrollBar;
  689.     Rect             pRect;
  690.  
  691.     theData = ( WDHandle )GetWRefCon( whichWindow );
  692.     if ( theData != nil )
  693.     {
  694.         theScrollBar = ( *theData )->scBar;
  695.         HideControl( theScrollBar );
  696.         pRect = whichWindow->portRect;
  697.     
  698.         MoveControl( theScrollBar, pRect.right - ( SBarWidth - 1 ), -1 );
  699.         SizeControl( theScrollBar, SBarWidth, ( pRect.bottom + 1 )
  700.                     - ( pRect.top - 1 ) - ( SBarWidth - 1 ));
  701.         ShowControl( theScrollBar );
  702.         ValidRect( &( *theScrollBar )->contrlRect );
  703.     }
  704. }
  705.  
  706. DoGoAway( theEvent, whichWindow )
  707.     EventRecord    *theEvent;
  708.     WindowPtr    whichWindow;
  709. {
  710.     INTEGER        theWKind;
  711.     
  712.     theWKind = TGetWKind( whichWindow );
  713.     
  714.     if ( theWKind == userKind )
  715.     {
  716.         if ( whichWindow != TFrontWindow( userKind ))
  717.             TSelectWindow( whichWindow );
  718.         else if ( TrackGoAway( whichWindow, &theEvent->where ))
  719.             CloseDocWindow( whichWindow );
  720.     }
  721.     else if ( theWKind == toolKind )
  722.     {
  723.         if ( TrackGoAway( whichWindow, &theEvent->where ))
  724.         {
  725.             lastToolsItem--;
  726.             DelMenuItem( ToolsMenu, ItemOf( whichWindow, ToolsMenu ));
  727.             TDisposeWindow( whichWindow );
  728.         }
  729.     }
  730. }
  731.  
  732. DoKeyStroke( theEvent )
  733.     EventRecord    *theEvent;
  734. {
  735.     INTEGER     ch;
  736.     LONGINT     menuChoice;
  737.  
  738.     ch = ( INTEGER )( theEvent->message & charCodeMask );
  739.  
  740.     if ( theEvent->modifiers & cmdKey )
  741.     {
  742.         if ( theEvent->what != autoKey )
  743.         {
  744.             menuChoice = MenuKey( ch );
  745.             DoMenuChoice( menuChoice );
  746.         }
  747.     }
  748. }
  749.  
  750. DoUpdate( theEvent )
  751.     EventRecord    *theEvent;
  752. {
  753.     GrafPtr        savePort;
  754.     WindowPtr    whichWindow;
  755.     WDHandle    theData;
  756.     INTEGER        theWKind;
  757.  
  758.     GetPort( &savePort );
  759.  
  760.     whichWindow = ( WindowPtr )theEvent->message;
  761.     theWKind = TGetWKind( whichWindow );
  762.     SetPort( whichWindow );
  763.     BeginUpdate( whichWindow );
  764.  
  765.     if ( theWKind == userKind )
  766.     {
  767.         EraseRect( &whichWindow->portRect );
  768.     
  769.         if ( GetWRefCon( whichWindow ) != nil )
  770.         {
  771.             DrawGrowIcon( whichWindow );
  772.             DrawControls( whichWindow );
  773.         }
  774.     }
  775.     else if ( theWKind == toolKind )
  776.     {
  777.         EraseRect( &whichWindow->portRect );
  778.     }
  779.     EndUpdate( whichWindow );
  780.     SetPort( savePort );
  781. }
  782.  
  783. DoActivate( theEvent )
  784.     EventRecord    *theEvent;
  785. {
  786.     WindowPtr    whichWindow,
  787.                 theFrontWindow;
  788.     WDHandle    theData;
  789.     INTEGER        theWKind,
  790.                 frontWKind;
  791.  
  792.     whichWindow = ( WindowPtr )theEvent->message;
  793.     SetPort( whichWindow );
  794.     theWKind = TGetWKind( whichWindow );
  795.  
  796.     if ( theWKind == userKind )
  797.     {
  798.         theData = (WDHandle )GetWRefCon( whichWindow );
  799.     
  800.         if ( theData != nil )
  801.         {
  802.             HLock( theData );
  803.             if ( theEvent->modifiers & activeFlag )
  804.             {
  805.                 ShowControl(( *theData )->scBar );
  806.                 
  807.                 DisableItem( EditMenu, UndoItem  );
  808.                 DisableItem( EditMenu, CutItem   );
  809.                 DisableItem( EditMenu, CopyItem  );
  810.                 DisableItem( EditMenu, PasteItem );
  811.                 DisableItem( EditMenu, ClearItem );
  812.             }
  813.             else
  814.             {
  815.                 HideControl(( *theData )->scBar );
  816.         
  817.                 theFrontWindow = FrontWindow();
  818.                 frontWKind     = TGetWKind( theFrontWindow );
  819.                 if ( frontWKind == systemKind )
  820.                 {
  821.                     EnableItem( EditMenu, UndoItem  );
  822.                     EnableItem( EditMenu, CutItem   );
  823.                     EnableItem( EditMenu, CopyItem  );
  824.                     EnableItem( EditMenu, PasteItem );
  825.                     EnableItem( EditMenu, ClearItem );
  826.                 }
  827.             }
  828.             HUnlock( theData );
  829.             DrawGrowIcon( whichWindow );
  830.         }
  831.     }
  832. }
  833.  
  834. INTEGER
  835. ItemOf( whichWindow, whichMenu )
  836.     WindowPtr    whichWindow;
  837.     MenuHandle    whichMenu;
  838. {
  839.     char        theTitle[ 255 ],
  840.                 theMenu [ 255 ];
  841.     Boolean        done;
  842.     INTEGER        theItem;
  843.     
  844.     GetWTitle( whichWindow, theTitle );
  845.     
  846.     for ( done = false,
  847.             theItem = 1;
  848.           done == false;
  849.           theItem++         )
  850.     {
  851.         GetItem( whichMenu, theItem, theMenu );
  852.         if ( strcmp( theTitle, theMenu ) == 0 )
  853.         {
  854.             done = true;
  855.             theItem--;
  856.         }
  857.     }
  858.     
  859.     return( theItem );
  860. }
  861.  
  862. WindowPtr
  863. WindowOf( whichMenu, whichItem )
  864.     MenuHandle    whichMenu;
  865.     INTEGER        whichItem;
  866. {
  867.     char        theTitle[ 255 ],
  868.                 theMenu [ 255 ];
  869.     Boolean        done;
  870.     INTEGER        wantedKind,
  871.                 theWKind;
  872.     WindowPeek    loopWindow,
  873.                 wantedWindow;
  874.     
  875.     GetItem( whichMenu, whichItem, theMenu );
  876.     if ( whichMenu == WindowsMenu )
  877.         wantedKind = userKind;
  878.     else
  879.         wantedKind = toolKind;
  880.     
  881.     for ( done = false,
  882.             loopWindow   =
  883.             wantedWindow = windowList;
  884.           done == false  &&  loopWindow != nil;
  885.           loopWindow = loopWindow->nextWindow )
  886.     {
  887.         theWKind = TGetWKind( loopWindow );
  888.         if ( theWKind == wantedKind )
  889.         {
  890.             GetWTitle( loopWindow, theTitle );
  891.             if ( strcmp( theTitle, theMenu ) == 0 )
  892.             {
  893.                 wantedWindow = loopWindow;
  894.                 done = true;
  895.             }
  896.         }
  897.     }
  898.         
  899.     return(( WindowPtr )wantedWindow );
  900. }
  901.  
  902. void
  903. SetBold( theDialog, bolditem )
  904.     DialogPtr        theDialog;
  905.     short            bolditem;
  906. {
  907.     INTEGER            itemType;
  908.     Handle            itemHandle;
  909.     Rect            itemRect;
  910.     pascal void        OutlineButton();
  911.  
  912.         /* Get the OK button's display rectangle, enlarge the
  913.            rectangle, and set up the useritem with this rectangle
  914.            and a pointer to the OutlineButton function. */
  915.            
  916.     GetDItem( theDialog, okButton, &itemType, &itemHandle, &itemRect );
  917.     InsetRect( &itemRect, -3, -3 );
  918.     SetDItem( theDialog, bolditem, userItem,
  919.               ( Handle )OutlineButton, &itemRect );
  920. }
  921.  
  922. pascal void
  923. OutlineButton( theDialog, theItem )
  924.     DialogPtr        theDialog;
  925.     INTEGER            theItem;
  926. {
  927.     INTEGER            itemType;
  928.     Handle            itemHandle;
  929.     Rect            itemRect;
  930.     PenState        savePen;
  931.     
  932.         /* Get the bounding rectangle of the OK button item
  933.            and boldly outline it. */
  934.     
  935.     GetDItem( theDialog, okButton, &itemType, &itemHandle, &itemRect );
  936.     GetPenState( &savePen );
  937.     PenSize( 3,3 );
  938.     InsetRect( &itemRect, -4, -4 );
  939.     FrameRoundRect( &itemRect, 16, 16 );
  940.     SetPenState( &savePen );
  941. }
  942.